home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-02 / pwxms.zip / XMS.PAS < prev    next >
Pascal/Delphi Source File  |  1993-01-04  |  11KB  |  357 lines
  1.  
  2. {
  3.      Oil Management Services Limited
  4.  
  5.      Turbo Pascal Standard Library
  6.  
  7.      XMS.PAS - eXtended Memory Support
  8.  
  9.      Part Number : 20-0013
  10.  
  11.      Version : 1.00
  12.  
  13.      Date : 24th July 1989
  14. }
  15.  
  16. UNIT XMS ;
  17.  
  18. {
  19.      Export Declarations & Definitions Section
  20. }
  21.  
  22. INTERFACE
  23.  
  24. {
  25.      The purpose of this Unit is to implement an interface between a Turbo
  26.      Pascal program and an XMS driver. It implements those functions defined
  27.      in the Extended Memory Specification (XMS) Version 2.00 for MS-DOS.
  28.  
  29.      XMS allows DOS programs to utilise additional memory found in Intel's
  30.      80286 and 80386 based machines in a consistent, machine independent
  31.      manner. With some restrictions, XMS adds almost 64K to the 640K which
  32.      DOS programs can access directly. Depending on avaliable hardware, XMS
  33.      may provide even more memory to DOS programs. XMS also provides DOS
  34.      programs with a standard method of storing data in extended memory.
  35. }
  36.  
  37.  
  38. {
  39.      Constants for XMSStatus Return Values
  40. }
  41.  
  42. CONST
  43.  
  44.      XMSStatus_OperationSuccessful      = $00 ;
  45.      XMSStatus_FunctionNotImplemented   = $80 ;
  46.      XMSStatus_VDISKDetected            = $81 ;
  47.      XMSStatus_A20Error                 = $82 ;
  48.      XMSStatus_GeneralDriverError       = $8e ;
  49.      XMSStatus_UnRecoverableDriverError = $8f ;
  50.      XMSStatus_HMADoesNotExist          = $90 ;
  51.      XMSStatus_HMAInUse                 = $91 ;
  52.      XMSStatus_LessThanHMAMIN           = $92 ;
  53.      XMSStatus_HMANotAllocated          = $93 ;
  54.      XMSStatus_A20StillEnabled          = $94 ;
  55.      XMSStatus_AllEMAllocated           = $a0 ;
  56.      XMSStatus_AllEMHandlesInUse        = $a1 ;
  57.      XMSStatus_HandleInvalid            = $a2 ;
  58.      XMSStatus_SourceHandleInvalid      = $a3 ;
  59.      XMSStatus_SourceOffsetInvalid      = $a4 ;
  60.      XMSStatus_DestHandleInvalid        = $a5 ;
  61.      XMSStatus_DestOffsetInvalid        = $a6 ;
  62.      XMSStatus_LengthInvalid            = $a7 ;
  63.      XMSStatus_MoveInvalidOverlap       = $a8 ;
  64.      XMSStatus_ParityError              = $a9 ;
  65.      XMSStatus_BlockNotLocked           = $aa ;
  66.      XMSStatus_BlockLocked              = $ab ;
  67.      XMSStatus_BlockLockCountOverflow   = $ac ;
  68.      XMSStatus_LockFails                = $ad ;
  69.      XMSStatus_SmallerUMBAvailiable     = $b0 ;
  70.      XMSStatus_NoUMBsAvaliable          = $b1 ;
  71.      XMSStatus_UMBSegmentNumberInvalid  = $b2 ;
  72.  
  73. VAR
  74.  
  75.      XMSStatus : BYTE     ;
  76.  
  77. {
  78.      XMS Driver Information Constants
  79. }
  80.  
  81. CONST
  82.  
  83.      XMSInstalled                    : BOOLEAN  = FALSE ;
  84.      XMSVersionNumber                : EXTENDED = 0.0   ;
  85.      XMSDriverInternalRevisionNumber : EXTENDED = 0.0   ;
  86.      XMSHMAExists                    : BOOLEAN  = FALSE ;
  87.  
  88. {
  89.      HMA Management Routines
  90. }
  91.  
  92. PROCEDURE XMSRequestHMA       ;
  93. PROCEDURE XMSReleaseHMA       ;
  94.  
  95. {
  96.      A20 Management Routines
  97. }
  98.  
  99. PROCEDURE XMSGlobalEnableA20  ;
  100. PROCEDURE XMSGlobalDisableA20 ;
  101. PROCEDURE XMSLocalEnableA20   ;
  102. PROCEDURE XMSLocalDisableA20  ;
  103. FUNCTION XMSQueryA20:BOOLEAN  ;
  104.  
  105. {
  106.      Extended Memory Management Routines
  107. }
  108.  
  109. FUNCTION XMSLargestFreeEMB:WORD ;
  110. FUNCTION XMSTotalFreeEM:WORD ;
  111. FUNCTION XMSAllocEMB(Amount:WORD):WORD ;
  112. PROCEDURE XMSFreeEMB(Handle:WORD) ;
  113.  
  114. PROCEDURE XMSMoveMemtoEMB(Handle1:WORD;Ptr1:POINTER;Length:LONGINT) ;
  115.  
  116. PROCEDURE __XMSMoveMemtoEMB(Handle1:WORD;Ptr1:POINTER;Offset2:LONGINT;Length:LONGINT) ;
  117. PROCEDURE XMSMoveMemtoMem(Ptr1,Ptr2:POINTER;Length:LONGINT) ;
  118. PROCEDURE XMSMoveEMBtoMem(Handle1:WORD;Ptr1:POINTER;Length:LONGINT) ;
  119. PROCEDURE __XMSMoveEMBtoMem(Handle1:WORD;Offset1:LONGINT;Ptr2:POINTER;Length:LONGINT) ;
  120. PROCEDURE XMSMoveEMBtoEMB(Handle1,Handle2:WORD;Length:LONGINT) ;
  121. FUNCTION XMSLockEMB(Handle:WORD):POINTER ;
  122. PROCEDURE XMSUnLockEMB(Handle:WORD) ;
  123. FUNCTION XMSGetEMBLockCount(Handle:WORD):BYTE ;
  124. FUNCTION XMSGetFreeEMBHandles(Handle:WORD):BYTE ;
  125. FUNCTION XMSGetEMBLength(Handle:WORD):WORD ;
  126. PROCEDURE XMSReAllocEMB(Handle,NewSize:WORD) ;
  127.  
  128. {
  129.      Upper Memory Management Routines
  130. }
  131.  
  132. FUNCTION XMSRequestUMB(VAR Amount:WORD):WORD ; { *** DO NOT USE YET --> BUGGY *** }
  133. PROCEDURE XMSReleaseUMB(SegmentNumber:WORD) ;
  134.  
  135. {
  136.      Miscellaneous
  137. }
  138.  
  139. FUNCTION HexStr(dd:BYTE):STRING ;
  140.  
  141. {
  142.      Implementation Section
  143. }
  144.  
  145. VAR
  146.  
  147. {
  148.      *** DO NOT MODIFY THIS IT REALLY SHOULD NOT BE EXPORTED ***
  149. }
  150.  
  151.      XMSControl : POINTER ;
  152.  
  153. IMPLEMENTATION
  154. {$f-}
  155. FUNCTION _XMSInstalled:BYTE                        ; EXTERNAL ;
  156. FUNCTION _XMSVersionNumber:WORD                    ; EXTERNAL ;
  157. FUNCTION _XMSDriverInternalRevisionNumber:WORD     ; EXTERNAL ;
  158. FUNCTION _XMSHMAExists:BYTE                        ; EXTERNAL ;
  159. PROCEDURE XMSRequestHMA                            ; EXTERNAL ;
  160. PROCEDURE XMSReleaseHMA                            ; EXTERNAL ;
  161. PROCEDURE XMSGlobalEnableA20                       ; EXTERNAL ;
  162. PROCEDURE XMSGlobalDisableA20                      ; EXTERNAL ;
  163. PROCEDURE XMSLocalEnableA20                        ; EXTERNAL ;
  164. PROCEDURE XMSLocalDisableA20                       ; EXTERNAL ;
  165. FUNCTION _XMSQueryA20:WORD                         ; EXTERNAL ;
  166. FUNCTION XMSLargestFreeEMB:WORD                    ; EXTERNAL ;
  167. FUNCTION XMSTotalFreeEM:WORD                       ; EXTERNAL ;
  168. FUNCTION XMSAllocEMB(Amount:WORD):WORD             ; EXTERNAL ;
  169. PROCEDURE XMSFreeEMB(Handle:WORD)                  ; EXTERNAL ;
  170. PROCEDURE _XMSMoveEMB(ExtMemMoveStructPtr:POINTER) ; EXTERNAL ;
  171. FUNCTION XMSLockEMB(Handle:WORD):POINTER           ; EXTERNAL ;
  172. PROCEDURE XMSUnLockEMB(Handle:WORD)                ; EXTERNAL ;
  173. FUNCTION XMSGetEMBLockCount(Handle:WORD):BYTE      ; EXTERNAL ;
  174. FUNCTION XMSGetFreeEMBHandles(Handle:WORD):BYTE    ; EXTERNAL ;
  175. FUNCTION XMSGetEMBLength(Handle:WORD):WORD         ; EXTERNAL ;
  176. PROCEDURE XMSReAllocEMB(Handle,NewSize:WORD)       ; EXTERNAL ;
  177. FUNCTION XMSRequestUMB(VAR Amount:WORD):WORD       ; EXTERNAL ;
  178. PROCEDURE XMSReleaseUMB(SegmentNumber:WORD)        ; EXTERNAL ;
  179. {$f+}
  180. PROCEDURE _XMSNotInitialised                       ; EXTERNAL ;
  181. {$f-}
  182. {$L XMS.OBJ}
  183.  
  184. {
  185.      This Function Converts BCD Numbers to Extended Type Reals
  186. }
  187.  
  188. FUNCTION BCDtoExtended(BCD:WORD):EXTENDED ;
  189.  
  190. {
  191.      Declarations & Definitions
  192. }
  193.  
  194. VAR
  195.  
  196.      Digit : WORD     ;
  197.      dd    : EXTENDED ;
  198.  
  199. {
  200.      MAIN - Statement Part of BCDtoExtended
  201. }
  202.  
  203. BEGIN
  204.      dd := 0.0 ;
  205.      Digit := (BCD AND $f000) SHR 12 ; dd := dd + Digit * 1.0e+1 ;
  206.      Digit := (BCD AND $0f00) SHR 08 ; dd := dd + Digit * 1.0e+0 ;
  207.      Digit := (BCD AND $00f0) SHR 04 ; dd := dd + Digit * 1.0e-1 ;
  208.      Digit := (BCD AND $000f) SHR 00 ; dd := dd + Digit * 1.0e-2 ;
  209.      BCDtoExtended := dd ;
  210. END ;
  211.  
  212. {
  213.      This Function checks to see if the A20 line is physically enabled.
  214.      It does this in a hardware independent manner by seeing if
  215.      "memory wrap" occurs
  216. }
  217.  
  218. FUNCTION XMSQueryA20:BOOLEAN ;
  219. BEGIN
  220.      XMSQueryA20 := _XMSQueryA20 = $0001 ;
  221. END ;
  222.  
  223. {
  224.      Extended Memory Move Structure Definition
  225. }
  226.  
  227. VAR
  228.  
  229.      ExtMemMoveStruct : RECORD
  230.                               Length       : LONGINT ;
  231.                               SourceHandle : WORD    ;
  232.                               SourceOffset : POINTER ;
  233.                               DestHandle   : WORD    ;
  234.                               DestOffset   : POINTER ;
  235.                         END ;
  236.  
  237. {
  238.      These procedures attempt to transfer a block of data from one
  239.      location to another. They are primarily intended for moving blocks
  240.      of data between conventional memory and extended memory, however
  241.      they can be used for moving blocks within conventional memory and
  242.      within extended memory.
  243. }
  244.  
  245. PROCEDURE XMSMoveMemToMem ;
  246. BEGIN
  247.      ExtMemMoveStruct.Length := Length ;
  248.      ExtMemMoveStruct.SourceHandle := $0000 ;
  249.      ExtMemMoveStruct.SourceOffset := Ptr1  ;
  250.      ExtMemMoveStruct.DestHandle   := $0000 ;
  251.      ExtMemMoveStruct.DestOffset   := Ptr2  ;
  252.      _XMSMoveEMB(@ExtMemMoveStruct) ;
  253. END ;
  254.  
  255. PROCEDURE XMSMoveMemToEMB ;
  256. BEGIN
  257.      ExtMemMoveStruct.Length := Length ;
  258.      ExtMemMoveStruct.SourceHandle := $0000   ;
  259.      ExtMemMoveStruct.SourceOffset := Ptr1    ;
  260.      ExtMemMoveStruct.DestHandle   := Handle1 ;
  261.      ExtMemMoveStruct.DestOffset   := NIL     ;
  262.      _XMSMoveEMB(@ExtMemMoveStruct) ;
  263. END ;
  264.  
  265. PROCEDURE __XMSMoveMemToEMB ;
  266. BEGIN
  267.      ExtMemMoveStruct.Length := Length ;
  268.      ExtMemMoveStruct.SourceHandle := $0000   ;
  269.      ExtMemMoveStruct.SourceOffset := Ptr1    ;
  270.      ExtMemMoveStruct.DestHandle   := Handle1 ;
  271.      ExtMemMoveStruct.DestOffset   := POINTER(Offset2) ;
  272.      _XMSMoveEMB(@ExtMemMoveStruct) ;
  273. END ;
  274.  
  275. PROCEDURE XMSMoveEMBToMem ;
  276. BEGIN
  277.      ExtMemMoveStruct.Length := Length ;
  278.      ExtMemMoveStruct.SourceHandle := Handle1 ;
  279.      ExtMemMoveStruct.SourceOffset := NIL     ;
  280.      ExtMemMoveStruct.DestHandle   := $0000   ;
  281.      ExtMemMoveStruct.DestOffset    := Ptr1   ;
  282.      _XMSMoveEMB(@ExtMemMoveStruct) ;
  283. END ;
  284.  
  285. PROCEDURE __XMSMoveEMBToMem ;
  286. BEGIN
  287.      ExtMemMoveStruct.Length := Length ;
  288.      ExtMemMoveStruct.SourceHandle := Handle1 ;
  289.      ExtMemMoveStruct.SourceOffset := POINTER(Offset1) ;
  290.      ExtMemMoveStruct.DestHandle   := $0000   ;
  291.      ExtMemMoveStruct.DestOffset    := Ptr2   ;
  292.      _XMSMoveEMB(@ExtMemMoveStruct) ;
  293. END ;
  294.  
  295. PROCEDURE XMSMoveEMBToEMB ;
  296. BEGIN
  297.      ExtMemMoveStruct.Length := Length ;
  298.      ExtMemMoveStruct.SourceHandle := Handle1 ;
  299.      ExtMemMoveStruct.SourceOffset := NIL     ;
  300.      ExtMemMoveStruct.DestHandle   := Handle2 ;
  301.      ExtMemMoveStruct.DestOffset   := NIL     ;
  302.      _XMSMoveEMB(@ExtMemMoveStruct) ;
  303. END ;
  304.  
  305. {
  306.      This Function Converts a Byte to a Hex String
  307. }
  308.  
  309. FUNCTION HexStr ;
  310.  
  311. {
  312.      Declarations & Definitions
  313. }
  314.  
  315. CONST
  316.  
  317.      HexDigits : ARRAY[$0..$f] OF CHAR = ('0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f') ;
  318.  
  319. {
  320.      MAIN - Statement Part of HexStr
  321. }
  322.  
  323. BEGIN
  324.      HexStr := HexDigits[dd AND $f0 shr 4] + HexDigits[dd AND $0f] ;
  325. END ;
  326.  
  327. {
  328.      MAIN - Start Up Code for XMS.PAS
  329. }
  330.  
  331. BEGIN
  332.  
  333. {
  334.      Install Default XMS Control Function
  335. }
  336.  
  337.      XMSControl := @_XMSNotInitialised ;
  338.  
  339. {
  340.      Check XMS Driver is Installed & Try to Install XMS Control Function
  341. }
  342.  
  343.      XMSInstalled := _XMSInstalled = $80 ;
  344.  
  345. {
  346.      Set-Up Exported Variables
  347. }
  348.  
  349.      IF (XMSInstalled) THEN BEGIN
  350.          XMSVersionNumber := BCDtoExtended(_XMSVersionNumber) ;
  351.          XMSDriverInternalRevisionNumber := BCDtoExtended(_XMSDriverInternalRevisionNumber) ;
  352.          XMSHMAExists := _XMSHMAExists = $0001 ;
  353.      END ;
  354.  
  355. END.
  356.  
  357.